/**
 * @author:cavion(曹仁道)
 * @email:caorendao187@163.com
 * 2016年8月27日 
 */
package org.rk.core.common.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.springframework.util.StringUtils;
import org.apache.commons.lang3.RandomStringUtils;

/**
 * @author:cavion
 * @描述：字符串工具类
 * 2016年8月27日 下午3:21:13
 */
public class RkStrUtil extends org.apache.commons.lang3.StringUtils{
	/**
	 * @author:cavion
	 * @描述：判断str字符串中含有多少个str1字符串
	 * 2016年10月26日 下午9:26:44
	 * @param str
	 * @param str1
	 * @return
	 */
	public static Integer getStringNum(String str, String str1) {
		int x = 0;
		// 遍历数组的每个元素
		for (int i = 0; i <= str.length() - 1; i++) {
			String getstr = str.substring(i, (str1.length() - 1));
			if (getstr.equals(str1)) {
				x++;
			}
		}
		return x;
	}
	/**
	 * @author:cavion
	 * @描述：判断字符串数组中是否包含某字符串元素
	 * 2016年10月26日 下午9:27:30
	 * @param substring  某字符串
	 * @param source 源字符串数组
	 * @return
	 */
	public static boolean isIn(String substring, String[] source) {
		if (source == null || source.length == 0) {
			return false;
		}
		for (int i = 0; i < source.length; i++) {
			String aSource = source[i];
			if (aSource.equals(substring)) {
				return true;
			}
		}
		return false;
	}
	/**
	 * @author:cavion
	 * @描述：清除所有的换行和空格
	 * 2016年10月26日 下午9:28:15
	 * @param str
	 * @return
	 */
	public static String replaceBlank(String str) {
		String dest = "";
		if (str != null) {
			Pattern p = Pattern.compile("\\s*|\t|\r|\n");
			Matcher m = p.matcher(str);
			dest = m.replaceAll("");
		}
		return dest;
	}
	/**
	 * @author:cavion
	 * @描述：根据指定链接字符把map集合链接起来，name=value形式
	 * 2016年10月26日 下午9:33:19
	 * @param param
	 * @param jiontChart 链接字符
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static String map2Str(Map<String, String> param, String jiontChart) {
		StringBuffer result = new StringBuffer();
		if (param != null) {
			Set entries = param.entrySet();
			if (entries != null) {
				int proNum = 0;
				Iterator iterator = entries.iterator();
				while (iterator.hasNext()) {
					Map.Entry entry = (Entry) iterator.next();//
					String name = entry.getKey().toString();
					String value = entry.getValue().toString();
					if (proNum == 0) {
						result.append(name + "=" + value);
					} else {
						result.append(jiontChart + name + "=" + value);
					}
					proNum++;
				}
			}
		}
		return result.toString();
	}
	
	/**
	 * 
	 * @author:cavion
	 * @描述：随机数和字母的组合
	 * 2016年10月26日 下午9:25:02
	 * @param len
	 * @return
	 */
	public static String generateWord(int len) {
		String[] beforeShuffle = new String[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D",
				"E", "F", "G", "H", "I", "J", "K", "L", "Y", "Z", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W",
				"X", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "y", "z", "m", "n", "o", "p", "q", "r",
				"s", "t", "u", "v", "w", "x" };
		List<String> list = Arrays.asList(beforeShuffle);
		Collections.shuffle(list);
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < list.size(); i++) {
			sb.append(list.get(i));
		}
		String afterShuffle = sb.toString();
		String result = afterShuffle.substring(0, len);
		return result;
	}
	public static boolean hasText(String str){
		if(StringUtils.hasText(trimToEmpty(str))){
			if("null".equals(str)){
				return false;
			}else{
				return true;
			}
		}else{
			return false;
		}
	}
	public static boolean hasLength(String str)    {
		return StringUtils.hasLength(str);
	}
	/**
	 * 数组转换成list
	 * @param args
	 * @return
	 */
	public List<String> arrayToList(String[] args){
		List<String> list=new ArrayList<String>();
		if(args==null||args.length==0){
			return list;
		}
		for(String str : args){
			if(hasText(str)){list.add(str);}
		}
		return list;
	}
	/**
	 * @author：cavion
	 * @方法描述：数组转换成list拍重复
	 * @param args
	 * @return
	 */
	public List<String> arrayToListNoDup(String[] args){
		List<String> list=new ArrayList<String>();
		if(args==null||args.length==0){
			return list;
		}
		for(String str : args){
			if(list.contains(str)){
				continue;
			}
			if(hasText(str)){list.add(str);}
		}
		return list;
	}
	
	public static String UnitMoreSpan(String str)    {
		if(str==null){
			return "";
		}
		return str.replaceAll("\\[s]+", "");
    }
	/**
	 * @author：cavion
	 * @方法描述：字符串对象去空格，如果为空返回null
	 * @param obj
	 * @return
	 */
	public static Object trimToNullIfStr(Object obj){
		if(obj==null){
			return null;
		}
		if(obj instanceof java.lang.String){
			String str=String.valueOf(obj);
			if(str==null||"".equals(str.trim())){
				return null;
			}else{
				return str.trim();
			}
		}
		return obj;
	}
	/**
	 * @author：cavion
	 * @方法描述：字符串对象去空格，如果为空返回空串
	 * @param obj
	 * @return
	 */
	public static Object trimToEmptyIfStr(Object obj){
		if(obj==null){
			return null;
		}
		if(obj instanceof java.lang.String){
			String str=String.valueOf(obj);
			if(str==null||"".equals(str.trim())){
				return "";
			}else{
				return str.trim();
			}
		}
		return obj;
	}
	//------------------------------------------------------------
	public static String parseToSplitStr(List<?> value) {
		if(value==null){
			return null;
		}
		if(value.size()==0){
			return "";
		}
		List<Object> target=new ArrayList<Object>();
		for(Object obj:value){
			if(obj!=null){
				target.add(obj);
			}
		}
		String str=RkStrUtil.join(target,",");
		return str;
	}
	
	public static String parseToSplitStr(Object[] value) {
		if(value==null){
			return null;
		}
		if(value.length==0){
			return "";
		}
		List<Object> target=new ArrayList<Object>();
		for(Object obj:value){
			if(obj!=null){
				target.add(obj);
			}
		}
		String str=RkStrUtil.join(target,",");
		return str;
	}
	//1,2,3
	public static Long[] parseToLongArray(String value) {
		String[] objectArray = value.split(",");
		if (objectArray != null && objectArray.length > 0) {
			Long[] longArray = new Long[objectArray.length];
			for (int i = 0; i < objectArray.length; i++) {
				longArray[i] = Long.parseLong(objectArray[i]);
			}
			return longArray;
		}
		return null;
	}
	/**
	 * 判断字符串是否匹配指定正则表达式
	 * @param input
	 * @param regex
	 * @return
	 */
	public static boolean verifyWord(String input, String regex) {
		if (input == null){
			input = "";
		}
		if (regex == null){
			regex = "";
		}
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(input);
		boolean flag = m.matches();
		return flag;
	}
	//------------------------------------------------------------	
	/**
	 * @author：cavion
	 * @方法描述：字符串首字母大写
	 * @param str
	 * @return
	 */
	public static String toUpCaseFirst(String str) {
		if (str == null || "".equals(str))
			return str;
		boolean flag = verifyWord(str, "^[A-Za-z0-9]+$");
		if (flag) {
			char temp[] = str.toCharArray();
			temp[0] = str.toUpperCase().toCharArray()[0];
			str = String.valueOf(temp);
		}
		return str;
	}
	/**
	 * @author：cavion
	 * @方法描述：字符串首字母小写
	 * @param str
	 * @return
	 */
	public static String toLowerCaseFirst(String str){
		if(str==null||str.length()==0){
			return str;
		}
		String first = str.substring(0, 1).toLowerCase();
		String rest = str.substring(1, str.length());
		String newStr = new StringBuffer(first).append(rest).toString();
		return newStr;
	}
	
	/**
	 * 字符串数组中每个元素首字母大写
	 * @param str
	 * @return
	 */
	public static String[] toUpCaseFirst(String str[]) {
		if (str == null || str.length == 0)
			return str;
		String result[] = new String[str.length];
		for (int i = 0; i < result.length; i++)
			result[i] = toUpCaseFirst(str[i]);

		return result;
	}
	//------------------------------------------------------------

	/**
	 * 返回指定长度的随机的数字字符串。
	 * 
	 * @param length
	 * @return
	 */
	public static String getRandomNumber(int length) {
		String ret = "";
		for (int i = 0; i < length; i++) {
			ret += RandomStringUtils.random(9);
		}
		return ret;
	}

	/**
	 * 是否是降序或者升序
	 * @param str
	 * @param ascOrDesc
	 * @return
	 */
	public static boolean isAscDesc(String str, int ascOrDesc) {
		char last = (char) (str.charAt(0) - ascOrDesc);
		for (int i = 0; i < str.length(); i++) {
			char c = str.charAt(i);
			if (c != (last + ascOrDesc)) {
				return false;
			}
			last = c;
		}
		return true;
	}
	public static Boolean convertToBool(String str,boolean defautlt){
		Boolean res=false;
		try{
			 res=Boolean.parseBoolean(str);
		}catch(Exception e){
			return defautlt;
		}
		return res;
	}
	/**
	 * 
	 * @author：曹仁道
	 * @描述：计算某个字符串中出现某个字符的次数
	 * @param str
	 * @param c
	 * @return
	 * 2016年10月11日 下午4:38:10
	 */
	public static int strCountChar(String str,char c){
		int num = 0;
		char[] chars = str.toCharArray();
		for(int i = 0; i < chars.length; i++){
		    if(c == chars[i]){
		    	num++;
		    }
		}
		return num;
	}

	/**
	 * @方法描述：字符串数组转换成字符串
	 * @author:曹仁道
	 * 2016年10月28日 下午2:51:11
	 * @param str
	 * @return
	 */
	public static String strArrToStr(String[] str,String jionChar){
		StringBuffer sb=new StringBuffer();
		for (String string : str) {
			sb.append(string).append(jionChar);
		}
		return sb.toString();
	}
}
